package com.itheima.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.bean.Category;
import com.itheima.bean.MyPage;
import com.itheima.bean.Setmeal;
import com.itheima.bean.SetmealDish;
import com.itheima.dao.SetmealDao;
import com.itheima.dto.SetmealDto;
import com.itheima.service.CategoryService;
import com.itheima.service.SetmealDishService;
import com.itheima.service.SetmealService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class SetmealServiceImpl implements SetmealService {

    @Autowired
    private SetmealDao setmealDao;
    @Lazy
   @Autowired
    private CategoryService categoryService;
   @Autowired
   private SetmealDishService setmealDishService;
    public List<Setmeal> findAll(long id){
        //创建一个条件对象
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.eq(Setmeal::getCategoryId,id);
        //返回查询的集合
        return setmealDao.selectList(qw);
    }

    @Override
    public IPage<SetmealDto> findPage(MyPage page) {
        //先对套餐进行分页查询,设置分页查询的页数与每页展示的条数
        IPage<Setmeal> ip = new Page<>(page.getPage(),page.getPageSize());
        //创建条件对象
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        //设置按套餐名模糊查询的条件
        qw.like(page.getName()!=null,Setmeal::getName,page.getName());

        //调用dao对象进行查询
        IPage<Setmeal> p = setmealDao.selectPage(ip, qw);
        //获取当前页的集合对象
        List<Setmeal> list = p.getRecords();
        System.out.println(list);
        //对当前页的数据集合对象以流的方式进行遍历
        List<SetmealDto> setmealDtoList = list.stream().map((setmeal)->{
            //创建SetmealDto对象
            SetmealDto setmealDto = new SetmealDto();
            //调用category的service对象进行根据setmeal的外键id进行查询
            Category category = categoryService.findById(setmeal.getCategoryId());
            //调用setmealDishService对象更具setmeal的id为条件进行查询，获取setmealDish对象
            List<SetmealDish> setmealDishlist = setmealDishService.findById(setmeal.getId());
            //调用工具类将Setmeal的属性注入到SetmealDto中
            BeanUtils.copyProperties(setmeal,setmealDto);
            //将套餐分类名添加到setmealDto中
            setmealDto.setCategoryName(category.getName());
            //将获取的套餐中的菜品添加到，setmealDto中的菜品集合属性中
            setmealDto.setSetmealDishes(setmealDishlist);
            //返回setmealDto对象
            return setmealDto;
            //调用流的方法将遍历出来的setmealDto存入一个集合
        }).collect(Collectors.toList());
        //创建一个泛型为SetmealDto的IPage对象
        IPage<SetmealDto> iPage = new Page<>();
        //将上面获取的泛型为SetmealDto的集合添加到IPage对象的Records属性中
        iPage.setRecords(setmealDtoList);
        //将setmeal分页获取tobal赋值到IPage的属性上
        iPage.setTotal(p.getTotal());

        //返回IPage对象
        return iPage;
    }

    @Override
    public int add(SetmealDto setmealDto) {
        //先进行套餐添加
        int row = setmealDao.insert(setmealDto);
        //判断套餐是否添加成功
        if (row > 0){
            //添加成功后，获取setmealDto中的SetmealDish套餐菜品集合
            List<SetmealDish> list = setmealDto.getSetmealDishes();
            //定义一个旗帜变量记录每次套餐菜品添加的次数
            int row2 = 0;
            //判断菜品集合是否不为空，不为空则遍历集合，调用SetmeaDish中Service层的添加方法添加每一个遍历的SetmealDish对象
            if (list!=null && list.size()!=0){

                for (SetmealDish setmealDish : list) {
                    //将套餐的id添加为套餐菜品的外键属性中
                    setmealDish.setSetmealId(setmealDto.getId());
                    row2 += setmealDishService.add(setmealDish);
                }
                row = row2 == list.size() ? 1 : 0 ;
            }
        }
        return row;
    }

    @Override
    public int delete(List<Long> ids) {
        //先根据id进行查询判断是否处于起售卖状态
        //创建条件对象
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        //添加查询条件
        qw.eq(Setmeal::getStatus,1);
        qw.in(Setmeal::getId,ids);
        //调用方法状态为启售的套餐的总数
        Integer row = setmealDao.selectCount(qw);
        //判断row的值是否大于0，大于0则让删除影响行数返回0，删除失败,否则则进行删除操作
        if(row>0){
            return 0;
        }else {
            //进行删除操作，将要删除的id传入方法参数中
            int row1 = setmealDao.deleteBatchIds(ids);
            //判断是否删除套餐成功，删除成功则根据套餐的id删除套餐中的菜品
            if (row1>1){
                for (Long id : ids) {
                    int row2 = setmealDishService.delete(id);
                }
            }
            return row1;
        }
    }

    @Override
    public int update(SetmealDto setmealDto) {
        //先对套餐进行更新
        int row = setmealDao.updateById(setmealDto);

        //获取套餐中的菜品集合
        List<SetmealDish> list = setmealDto.getSetmealDishes();
        //判断是否更新成功，更新成功则删除套餐里面的菜品
        if (row > 0){
            //判断改套餐里面有没有菜品，有则先根据，套餐id进行删除，然后添加，没有则返回上面套餐更新影响行数
            if(list!=null && list.size()!=0){
                //调用套餐菜品Service层的删除方法，根据套餐id删除套餐内的菜品
                int row1 = setmealDishService.delete(setmealDto.getId());
                //定义一个旗帜变量记录添加成功的次数
                int row2 = 0;
                //遍历集合进行添加套餐菜品
                for (SetmealDish setmealDish : list) {
                    //将套餐id赋值给套餐菜品中的外键id
                    setmealDish.setSetmealId(setmealDto.getId());
                    //记录添加成功的次数
                    row2 += setmealDishService.add(setmealDish);
                }
                //判断添加成功的次数是否与集合总数相等，相等将row赋值为1，反之为0
                row = row2==list.size()? 1 : 0;
            }
        }
        return row;
    }

    @Override
    public int updateStatus(int status, List<Long> ids) {
        //定义一个旗帜变量记录，修改成功的次数
        int row = 0;
        //先判断是起售还是停售请求，起售请求则遍历id进行查询，将所有状态改为1，反之改为0，返回影响行数
        if (status==1){
            for (Long id : ids) {
                //获取套餐对象
                Setmeal setmeal = setmealDao.selectById(id);
                //修改其中的状态为1
                setmeal.setStatus(1);
                //在调用dao进行修改操作
                row += setmealDao.updateById(setmeal);
            }
            //判断修改音箱行数是否跟id集合相等，相等则返回1
            return row == ids.size() ? 1 : 0;
        }
        //停售请求
        for (Long id : ids) {
            //获取套餐对象
            Setmeal setmeal = setmealDao.selectById(id);
            //修改其中的状态为1
            setmeal.setStatus(0);
            //在调用dao进行修改操作
            row += setmealDao.updateById(setmeal);
        }
        return row == ids.size() ? 1 : 0;
    }

    @Override
    public List<Setmeal> list(long categoryId, int status) {
        //创建条件对象
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        //添加查寻套餐条件
        qw.eq(Setmeal::getCategoryId,categoryId);
        qw.eq(Setmeal::getStatus,status);
        //调用dao进行查询并返回套餐的集合对象
        return setmealDao.selectList(qw);
    }
}
